#ifndef THREAD_TEST_H
#define THREAD_TEST_H
#include <iostream>
#include <thread>
#include <vector>
#include <queue>
#include <functional>
#include <mutex>
#include <condition_variable>
#include <memory>
#include <stdexcept>

class thread_test
{
public:
    static thread_test& getInstance(size_t numThreads = std::thread::hardware_concurrency()) {
        static thread_test instance(numThreads);
        return instance;
    }

    // // 提交任务
    // template<typename F>
    // void enqueue_normal(F&& task) {
    //     {
    //         std::unique_lock<std::mutex> lock(mMutex);
    //         mConditionFull.wait(lock, [this] { return mTasks.size() < mMaxTasks; });
    //         mTasks.emplace(std::forward<F>(task));
    //     }
    //     mCondition.notify_one(); // 通知一个等待的线程
    // }

    // 提交任务，带优先级
    void enqueue_pro(std::function<void()> task, int priority=100) {
        {
            std::unique_lock<std::mutex> lock(mMutex);
            mConditionFull.wait(lock, [this] { return mTasks_pro.size() < mMaxTasks; });
            mTasks_pro.emplace(priority, std::move(task)); // 将任务和优先级一起放入队列
        }
        mCondition.notify_one(); // 通知一个等待的线程
    }

    thread_test(const thread_test&) = delete;
    thread_test& operator=(const thread_test&) = delete;



private:
    thread_test(size_t numThreads);
    ~thread_test();

    // 使用优先级队列
    using Task = std::pair<int, std::function<void()>>;
    struct Compare {
        bool operator()(const Task& a, const Task& b) {
            return a.first > b.first; // 小的优先级值表示高优先级
        }
    };
    std::priority_queue<Task, std::vector<Task>, Compare> mTasks_pro; // 优先级任务队列
    std::vector<std::thread> mWorkers; // 工作线程
    std::queue<std::function<void()>> mTasks; // 任务队列
    std::mutex mMutex; // 互斥锁
    std::condition_variable mCondition; // 条件变量
    std::condition_variable mConditionFull; // 任务队列满的条件变量
    bool mStop = false; // 停止标志
    const size_t mMaxTasks; // 最大任务数
};

#endif // THREAD_TEST_H
